import { taskStateManager, TaskStatus } from '../services/task-state-manager'
import { webSocketService } from '../services/websocket-service'
import type { UnifiedTaskMessage } from '../services/websocket-service'

/**
 * 任务提交选项
 */
export interface TaskSubmitOptions {
  taskId: string          // 任务ID
  taskType: string        // 任务类型
  businessId: string      // 业务ID（如书籍ID）
  params?: any            // 任务参数
  onStart?: () => void   // 任务开始回调
  onProgress?: (progress: number, message: string) => void  // 进度回调
  onComplete?: (result?: any) => void  // 完成回调
  onError?: (error: string) => void    // 错误回调
  onCancel?: () => void   // 取消回调
}

/**
 * 任务提交服务
 */
class TaskSubmitService {
  /**
   * 提交任务（带防重复检查）
   * @param options 任务提交选项
   * @returns 是否成功提交
   */
  async submitTask(options: TaskSubmitOptions): Promise<boolean> {
    const { taskId, taskType, params } = options
    
    // 检查任务是否已在运行
    if (taskStateManager.isRunning(taskId)) {
      console.warn(`任务 ${taskId} 已在运行中，跳过重复提交`)
      return false
    }
    
    // 标记任务开始
    const started = taskStateManager.startTask(taskId, taskType, params)
    if (!started) {
      return false
    }
    
    // 订阅任务消息
    this.subscribeToTaskMessages(options)
    
    // 调用任务开始回调
    if (options.onStart) {
      options.onStart()
    }
    
    // 这里应该调用后端API启动任务
    // 实际实现中，这里应该是一个HTTP请求
    try {
      // 示例：调用后端API
      // await api.startTask(taskType, businessId, params)
      
      // 模拟API调用
      console.log(`已提交任务 ${taskId} 到后端`)
      return true
    } catch (error) {
      console.error(`提交任务 ${taskId} 失败:`, error)
      
      // 标记任务失败
      taskStateManager.updateTaskStatus(taskId, TaskStatus.FAILED, 0, `提交失败: ${error}`)
      
      // 调用错误回调
      if (options.onError) {
        options.onError(`提交失败: ${error}`)
      }
      
      return false
    }
  }
  
  /**
   * 取消任务
   * @param taskId 任务ID
   * @returns 是否成功取消
   */
  cancelTask(taskId: string): boolean {
    // 取消本地任务状态
    const cancelled = taskStateManager.cancelTask(taskId)
    
    if (cancelled) {
      // 这里应该调用后端API取消任务
      // 实际实现中，这里应该是一个HTTP请求
      try {
        // 示例：调用后端API
        // await api.cancelTask(taskId)
        
        console.log(`已取消任务 ${taskId}`)
        return true
      } catch (error) {
        console.error(`取消任务 ${taskId} 失败:`, error)
        return false
      }
    }
    
    return false
  }
  
  /**
   * 订阅任务消息
   * @param options 任务提交选项
   */
  private subscribeToTaskMessages(options: TaskSubmitOptions): void {
    const { taskId, taskType } = options
    
    // 确保WebSocket已连接
    if (!webSocketService.isConnected()) {
      webSocketService.connect().catch(error => {
        console.error('WebSocket连接失败:', error)
      })
    }
    
    // 订阅任务进度更新
    webSocketService.subscribeToTaskProgress(taskType, taskId, (message: UnifiedTaskMessage) => {
      if (message.progress !== undefined && options.onProgress) {
        options.onProgress(message.progress, message.message)
      }
      
      // 更新本地任务状态
      taskStateManager.updateTaskStatus(taskId, message.status as TaskStatus, message.progress, message.message)
    })
    
    // 订阅任务完成通知
    webSocketService.subscribeToTaskCompletion(taskType, taskId, (_message: UnifiedTaskMessage) => {
      if (options.onComplete) {
        // UnifiedTaskMessage接口中没有result属性，所以这里不传递任何结果
        options.onComplete()
      }
    })
    
    // 订阅任务失败通知
    webSocketService.subscribeToTaskFailure(taskType, taskId, (message: UnifiedTaskMessage) => {
      if (options.onError) {
        options.onError(message.message)
      }
    })
  }
  
  /**
   * 检查任务是否正在运行
   * @param taskId 任务ID
   * @returns 是否正在运行
   */
  isTaskRunning(taskId: string): boolean {
    return taskStateManager.isRunning(taskId)
  }
  
  /**
   * 获取正在运行的任务
   * @param taskId 任务ID
   * @returns 任务信息
   */
  getRunningTask(taskId: string) {
    return taskStateManager.getRunningTask(taskId)
  }
  
  /**
   * 获取所有正在运行的任务
   * @returns 正在运行的任务列表
   */
  getAllRunningTasks() {
    return taskStateManager.getAllRunningTasks()
  }
}

// 导出单例实例
export const taskSubmitService = new TaskSubmitService()

// 导出便捷的组合式API
export function useTaskSubmit() {
  return {
    submitTask: (options: TaskSubmitOptions) => taskSubmitService.submitTask(options),
    cancelTask: (taskId: string) => taskSubmitService.cancelTask(taskId),
    isTaskRunning: (taskId: string) => taskSubmitService.isTaskRunning(taskId),
    getRunningTask: (taskId: string) => taskSubmitService.getRunningTask(taskId),
    getAllRunningTasks: () => taskSubmitService.getAllRunningTasks()
  }
}